home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / ufw / util.py < prev   
Text File  |  2009-09-23  |  13KB  |  538 lines
  1. #
  2. # util.py: utility functions for ufw
  3. #
  4. # Copyright 2008-2009 Canonical Ltd.
  5. #
  6. #    This program is free software: you can redistribute it and/or modify
  7. #    it under the terms of the GNU General Public License version 3,
  8. #    as published by the Free Software Foundation.
  9. #
  10. #    This program is distributed in the hope that it will be useful,
  11. #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. #    GNU General Public License for more details.
  14. #
  15. #    You should have received a copy of the GNU General Public License
  16. #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17. #
  18.  
  19. import errno
  20. import os
  21. import re
  22. import shutil
  23. import socket
  24. import struct
  25. import subprocess
  26. import sys
  27. from tempfile import mkstemp
  28.  
  29. debugging = False
  30.  
  31.  
  32. def get_services_proto(port):
  33.     '''Get the protocol for a specified port from /etc/services'''
  34.     proto = ""
  35.     try:
  36.         socket.getservbyname(port)
  37.     except Exception:
  38.         raise
  39.  
  40.     try:
  41.         socket.getservbyname(port, "tcp")
  42.         proto = "tcp"
  43.     except Exception:
  44.         pass
  45.  
  46.     try:
  47.         socket.getservbyname(port, "udp")
  48.         if proto == "tcp":
  49.             proto = "any"
  50.         else:
  51.             proto = "udp"
  52.     except Exception:
  53.         pass
  54.  
  55.     return proto
  56.  
  57.  
  58. def parse_port_proto(str):
  59.     '''Parse port or port and protocol'''
  60.     port = ""
  61.     proto = ""
  62.     tmp = str.split('/')
  63.     if len(tmp) == 1:
  64.         port = tmp[0]
  65.         proto = "any"
  66.     elif len(tmp) == 2:
  67.         port = tmp[0]
  68.         proto = tmp[1]
  69.     else:
  70.         raise ValueError
  71.     return (port, proto)
  72.  
  73.  
  74. def valid_address6(addr):
  75.     '''Verifies if valid IPv6 address'''
  76.     if not socket.has_ipv6:
  77.         warn("python does not have IPv6 support.")
  78.         return False
  79.  
  80.     # quick and dirty test
  81.     if len(addr) > 43 or not re.match(r'^[a-fA-F0-9:\./]+$', addr):
  82.         return False
  83.  
  84.     net = addr.split('/')
  85.     try:
  86.         socket.inet_pton(socket.AF_INET6, net[0])
  87.     except Exception:
  88.         return False
  89.  
  90.     if len(net) > 2:
  91.         return False
  92.     elif len(net) == 2:
  93.         # Check netmask specified via '/'
  94.         if not _valid_cidr_netmask(net[1], True):
  95.             return False
  96.  
  97.     return True
  98.  
  99.  
  100. def valid_address4(addr):
  101.     '''Verifies if valid IPv4 address'''
  102.     # quick and dirty test
  103.     if len(addr) > 31 or not re.match(r'^[0-9\./]+$', addr):
  104.         return False
  105.  
  106.     net = addr.split('/')
  107.     try:
  108.         socket.inet_pton(socket.AF_INET, net[0])
  109.         if not _valid_dotted_quads(net[0], False):
  110.             return False
  111.     except Exception:
  112.         return False
  113.  
  114.     if len(net) > 2:
  115.         return False
  116.     elif len(net) == 2:
  117.         # Check netmask specified via '/'
  118.         if not valid_netmask(net[1], False):
  119.             return False
  120.  
  121.     return True
  122.  
  123.  
  124. def valid_netmask(nm, v6):
  125.     '''Verifies if valid cidr or dotted netmask'''
  126.     return _valid_cidr_netmask(nm, v6) or _valid_dotted_quads(nm, v6)
  127.  
  128.  
  129. #
  130. # valid_address()
  131. #    version="6" tests if a valid IPv6 address
  132. #    version="4" tests if a valid IPv4 address
  133. #    version="any" tests if a valid IP address (IPv4 or IPv6)
  134. #
  135. def valid_address(addr, version="any"):
  136.     '''Validate IP addresses'''
  137.     if version == "6":
  138.         return valid_address6(addr)
  139.     elif version == "4":
  140.         return valid_address4(addr)
  141.     elif version == "any":
  142.         return valid_address4(addr) or valid_address6(addr)
  143.  
  144.     raise ValueError
  145.  
  146.  
  147. def normalize_address(orig, v6):
  148.     '''Convert address to standard form. Use no netmask for IP addresses. If
  149.        If netmask is specified and not all 1's, for IPv4 use cidr if possible,
  150.        otherwise dotted netmask and for IPv6, use cidr.
  151.     '''
  152.     net = []
  153.     changed = False
  154.     version = "4"
  155.     if v6:
  156.         version = "6"
  157.  
  158.     if '/' in orig:
  159.         net = orig.split('/')
  160.         # Remove host netmasks
  161.         if v6 and net[1] == "128":
  162.             del net[1]
  163.         elif not v6:
  164.             if net[1] == "32" or net[1] == "255.255.255.255":
  165.                 del net[1]
  166.     else:
  167.         net.append(orig)
  168.  
  169.     if not v6 and len(net) == 2 and _valid_dotted_quads(net[1], v6):
  170.         try:
  171.             net[1] = _dotted_netmask_to_cidr(net[1], v6)
  172.         except Exception:
  173.             # Not valid cidr, so just use the dotted quads
  174.             pass
  175.  
  176.     addr = net[0]
  177.     if len(net) == 2:
  178.         addr += "/" + net[1]
  179.         if not v6:
  180.             network = _address4_to_network(addr)
  181.             if network != addr:
  182.                 dbg_msg = "Using '%s' for address '%s'" % (network, addr)
  183.                 debug(dbg_msg)
  184.                 addr = network
  185.                 changed = True
  186.  
  187.     if not valid_address(addr, version):
  188.         dbg_msg = "Invalid address '%s'" % (addr)
  189.         debug(dbg_msg)
  190.         raise ValueError
  191.  
  192.     return (addr, changed)
  193.  
  194.  
  195. def open_file_read(f):
  196.     '''Opens the specified file read-only'''
  197.     try:
  198.         orig = open(f, 'r')
  199.     except Exception:
  200.         raise
  201.  
  202.     return orig
  203.  
  204.  
  205. def open_files(f):
  206.     '''Opens the specified file read-only and a tempfile read-write.'''
  207.     try:
  208.         orig = open_file_read(f)
  209.     except Exception:
  210.         raise
  211.  
  212.     try:
  213.         (tmp, tmpname) = mkstemp()
  214.     except Exception:
  215.         orig.close()
  216.         raise
  217.  
  218.     return { "orig": orig, "origname": f, "tmp": tmp, "tmpname": tmpname }
  219.  
  220.  
  221. def write_to_file(fd, s):
  222.     '''Write to the file descriptor and error out of 0 bytes written. Intended
  223.        to be used with open_files() and close_files().'''
  224.     if s == "":
  225.         return
  226.  
  227.     if not fd:
  228.         raise OSError(errno.ENOENT, "Not a valid file descriptor")
  229.  
  230.     if os.write(fd, s) <= 0:
  231.         raise OSError(errno.EIO, "Could not write to file descriptor")
  232.  
  233.  
  234. def close_files(fns, update = True):
  235.     '''Closes the specified files (as returned by open_files), and update
  236.        original file with the temporary file.
  237.     '''
  238.     fns['orig'].close()
  239.     os.close(fns['tmp'])
  240.  
  241.     if update:
  242.         try:
  243.             shutil.copystat(fns['origname'], fns['tmpname'])
  244.             shutil.copy(fns['tmpname'], fns['origname'])
  245.         except Exception:
  246.             raise
  247.  
  248.     try:
  249.         os.unlink(fns['tmpname'])
  250.     except OSError, e:
  251.         raise
  252.  
  253.  
  254. def cmd(command):
  255.     '''Try to execute the given command.'''
  256.     debug(command)
  257.     try:
  258.         sp = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
  259.     except OSError, e:
  260.         return [127, str(e)]
  261.  
  262.     out = sp.communicate()[0]
  263.     return [sp.returncode,out]
  264.  
  265.  
  266. def cmd_pipe(command1, command2):
  267.     '''Try to pipe command1 into command2.'''
  268.     try:
  269.         sp1 = subprocess.Popen(command1, stdout=subprocess.PIPE)
  270.         sp2 = subprocess.Popen(command2, stdin=sp1.stdout)
  271.     except OSError, e:
  272.         return [127, str(e)]
  273.  
  274.     out = sp2.communicate()[0]
  275.     return [sp2.returncode,out]
  276.  
  277.  
  278. def error(msg, exit=True):
  279.     '''Print error message and exit'''
  280.     try:
  281.         print >> sys.stderr, "ERROR: %s" % (msg)
  282.     except IOError:
  283.         pass
  284.  
  285.     if exit:
  286.         sys.exit(1)
  287.  
  288.  
  289. def warn(msg):
  290.     '''Print warning message'''
  291.     try:
  292.         print >> sys.stderr, "WARN: %s" % (msg)
  293.     except IOError:
  294.         pass
  295.  
  296.  
  297. def msg(msg, output=sys.stdout):
  298.     '''Print message'''
  299.     try:
  300.         print >> output, "%s" % (msg)
  301.     except IOError:
  302.         pass
  303.  
  304.  
  305. def debug(msg):
  306.     '''Print debug message'''
  307.     if debugging:
  308.         try:
  309.             print >> sys.stderr, "DEBUG: %s" % (msg)
  310.         except IOError:
  311.             pass
  312.  
  313.  
  314. def word_wrap(text, width):
  315.     '''
  316.     A word-wrap function that preserves existing line breaks
  317.     and most spaces in the text. Expects that existing line
  318.     breaks are posix newlines (\n).
  319.     '''
  320.     return reduce(lambda line, word, width=width: '%s%s%s' %
  321.                   (line,
  322.                    ' \n'[(len(line)-line.rfind('\n')-1
  323.                          + len(word.split('\n',1)[0]
  324.                               ) >= width)],
  325.                    word),
  326.                   text.split(' ')
  327.                  )
  328.  
  329.  
  330. def wrap_text(text):
  331.     '''Word wrap to a specific width'''
  332.     return word_wrap(text, 75)
  333.  
  334.  
  335. def human_sort(list):
  336.     '''Sorts list of strings into numeric order, with text case-insensitive.
  337.        Modifies list in place.
  338.  
  339.        Eg:
  340.        [ '80', 'a222', 'a32', 'a2', 'b1', '443', 'telnet', '3', 'http', 'ZZZ']
  341.  
  342.        sorts to:
  343.        ['3', '80', '443', 'a2', 'a32', 'a222', 'b1', 'http', 'telnet', 'ZZZ']
  344.     '''
  345.     norm = lambda t: int(t) if t.isdigit() else t.lower()
  346.     list.sort(key=lambda k: [ norm(c) for c in re.split('([0-9]+)', k)])
  347.  
  348.  
  349. def get_ppid(p=os.getpid()):
  350.     '''Finds parent process id for pid based on /proc/<pid>/stat. See
  351.        'man 5 proc' for details.
  352.     '''
  353.     try:
  354.         pid = int(p)
  355.     except:
  356.         raise ValueError("pid must be an integer")
  357.  
  358.     name = os.path.join("/proc", str(pid), "stat")
  359.     if not os.path.isfile(name):
  360.         raise IOError("Couldn't find '%s'" % (name))
  361.  
  362.     try:
  363.         ppid = file(name).readlines()[0].split()[3]
  364.     except Exception:
  365.         raise
  366.  
  367.     return int(ppid)
  368.  
  369.  
  370. def under_ssh(pid=os.getpid()):
  371.     '''Determine if current process is running under ssh'''
  372.     try:
  373.         ppid = get_ppid(pid)
  374.     except IOError, e:
  375.         warn_msg = _("Couldn't find pid (is /proc mounted?)")
  376.         warn(warn_msg)
  377.         return False
  378.     except Exception:
  379.         err_msg = _("Couldn't find parent pid for '%s'") % (str(pid))
  380.         raise ValueError(err_msg)
  381.  
  382.     # pid '1' is 'init' and '0' is the kernel. This should still work when
  383.     # pid randomization is in use, but needs to be checked.
  384.     if pid == 1 or ppid <= 1:
  385.         return False
  386.  
  387.     path = os.path.join("/proc", str(ppid), "stat")
  388.     if not os.path.isfile(path):
  389.         err_msg = _("Couldn't find '%s'") % (path)
  390.         raise ValueError(err_msg)
  391.  
  392.     try:
  393.         exe = file(path).readlines()[0].split()[1]
  394.     except:
  395.         err_msg = _("Could not find executable for '%s'") % (path)
  396.         raise ValueError(err_msg)
  397.     debug("under_ssh: exe is '%s'" % (exe))
  398.  
  399.     if exe == "(sshd)":
  400.         return True
  401.     else:
  402.         return under_ssh(ppid)
  403.  
  404.  
  405. #
  406. # Internal helper functions
  407. #
  408. def _valid_cidr_netmask(nm, v6):
  409.     '''Verifies cidr netmasks'''
  410.     num = 32
  411.     if v6:
  412.         num = 128
  413.  
  414.     if not re.match(r'^[0-9]+$', nm) or int(nm) < 0 or int(nm) > num:
  415.         return False
  416.  
  417.     return True
  418.  
  419.  
  420. def _valid_dotted_quads(nm, v6):
  421.     '''Verifies dotted quad ip addresses and netmasks'''
  422.     if v6:
  423.         return False
  424.     else:
  425.         if re.match(r'^[0-9]+\.[0-9\.]+$', nm):
  426.             quads = re.split('\.', nm)
  427.             if len(quads) != 4:
  428.                 return False
  429.             for q in quads:
  430.                 if not q or int(q) < 0 or int(q) > 255:
  431.                     return False
  432.         else:
  433.             return False
  434.  
  435.     return True
  436.  
  437. #
  438. # _dotted_netmask_to_cidr()
  439. # Returns:
  440. #   cidr integer (0-32 for ipv4 and 0-128 for ipv6)
  441. #
  442. # Raises exception if cidr cannot be found
  443. #
  444. def _dotted_netmask_to_cidr(nm, v6):
  445.     '''Convert netmask to cidr. IPv6 dotted netmasks are not supported.'''
  446.     cidr = ""
  447.     if v6:
  448.         raise ValueError
  449.     else:
  450.         if not _valid_dotted_quads(nm, v6):
  451.             raise ValueError
  452.  
  453.         mbits = 0
  454.         bits = long(struct.unpack('>L',socket.inet_aton(nm))[0])
  455.         found_one = False
  456.         for n in range(32):
  457.             if (bits >> n) & 1 == 1:
  458.                 found_one = True
  459.             else:
  460.                 if found_one:
  461.                     mbits = -1
  462.                     break
  463.                 else:
  464.                     mbits += 1
  465.  
  466.         if mbits >= 0 and mbits <= 32:
  467.             cidr = str(32 - mbits)
  468.  
  469.     if not _valid_cidr_netmask(cidr, v6):
  470.         raise ValueError
  471.  
  472.     return cidr
  473.  
  474.  
  475. #
  476. # _cidr_to_dotted_netmask()
  477. # Returns:
  478. #   dotted netmask string
  479. #
  480. # Raises exception if dotted netmask cannot be found
  481. #
  482. def _cidr_to_dotted_netmask(cidr, v6):
  483.     '''Convert cidr to netmask. IPv6 dotted netmasks not supported.'''
  484.     nm = ""
  485.     if v6:
  486.         raise ValueError
  487.     else:
  488.         if not _valid_cidr_netmask(cidr, v6):
  489.             raise ValueError
  490.         bits = 0L
  491.         for n in range(32):
  492.             if n < int(cidr):
  493.                 bits |= 1<<31 - n
  494.         nm = socket.inet_ntoa(struct.pack('>L', bits))
  495.  
  496.     if not _valid_dotted_quads(nm, v6):
  497.         raise ValueError
  498.  
  499.     return nm
  500.  
  501. def _address4_to_network(addr):
  502.     '''Convert an IPv4 address and netmask to a network address'''
  503.     if '/' not in addr:
  504.         debug("_address4_to_network: skipping address without a netmask")
  505.         return addr
  506.  
  507.     tmp = addr.split('/')
  508.     if len(tmp) != 2 or not _valid_dotted_quads(tmp[0], False):
  509.         raise ValueError
  510.  
  511.     host = tmp[0]
  512.     orig_nm = tmp[1]
  513.  
  514.     nm = orig_nm
  515.     if _valid_cidr_netmask(nm, False):
  516.         try:
  517.             nm = _cidr_to_dotted_netmask(nm, False)
  518.         except Exception:
  519.             raise
  520.  
  521.     # Now have dotted quad host and nm, find the network
  522.     host_bits = long(struct.unpack('>L',socket.inet_aton(host))[0])
  523.     nm_bits = long(struct.unpack('>L',socket.inet_aton(nm))[0])
  524.  
  525.     network_bits = host_bits & nm_bits
  526.     network = socket.inet_ntoa(struct.pack('>L', network_bits))
  527.  
  528.     return network + "/" + orig_nm
  529.  
  530. def get_iptables_version(exe="/sbin/iptables"):
  531.     '''Return iptables version'''
  532.     (rc, out) = cmd([exe, '-V'])
  533.     if rc != 0:
  534.         raise OSError(errno.ENOENT, "Error running '%s'" % (exe))
  535.     tmp = re.split('\s', out)
  536.     return re.sub('^v', '', tmp[1])
  537.  
  538.